import { checkAllCart, deleteCart, findCart, getNewCartGoods, insertCart, mergeCart, updateCart } from '@/api/cart'
// 购物车模块
// 其中state的数据格式是skuId,
/* attrsText,
stock,
id,
name,
price,
nowPrice: price,
picture: mainPictures[0],
selected: true,
isEffective: true,
count: num.value */
export default {
  namespaced: true,
  state() {
    return {
      // 购物车列表
      list: []
    }
  },
  getters: {
    validList(state) {
      //  有库存 而且 还是有效商品
      return state.list.filter((goods) => {
        return goods.stock > 0 && goods.isEffective
      })
    },
    // 有效商品件数
    validTotal(state, getters) {
      return getters.validList.reduce((p, c) => {
        return p + c.count
      }, 0)
    },
    // 有效商品的金额
    validAmount(state, getters) {
      return (
        getters.validList.reduce((p, c) => {
          return p + c.nowPrice * 100 * c.count
        }, 0) / 100
      )
    },
    // 无效商品列表
    invilidList(state) {
      return state.list.filter((item) => {
        return !item.isEffective
      })
    },
    // 已选商品列表
    selectedList(state, getters) {
      return getters.validList.filter((item) => {
        return item.selected
      })
    },
    // 已选商品总件数
    selectedTotal(state, getters) {
      return getters.selectedList.reduce((p, c) => {
        return p + c.count
      }, 0)
    },
    // 已选商品总金额
    selectedAmount(state, getters) {
      return (
        getters.selectedList.reduce((p, c) => {
          return p + Math.round(c.nowPrice * 100) * c.count
        }, 0) / 100
      )
    },
    // 是否全选
    isCheckAll(state, getters) {
      return getters.selectedList.length && getters.selectedList.length === getters.validList.length
    }
  },
  // 本地：id skuId name picture price nowPrice count attrsText selected stock isEffective
  // 线上：比上面多 isCollect 有用 discount 无用 两项项信息
  mutations: {
    // 约定加入购物车字段必须和后端保持一致 payload对象 的字段
    // 插入数据规则
    // 1. 先找一下是否有相同的商品,
    // 2. 如果有相同的商品,查询他的数量,累加到payload上,再保存最新位置,原来商品需要删除
    // 3.如果没有相同商品,保存在最新的位置即可
    insertCart(state, goods) {
      const sameIndex = state.list.findIndex((item) => item.skuId === goods.skuId)
      // 逻辑：有相同的给goods累加数量，删除相同skuId的商品
      if (sameIndex >= 0) {
        goods.count = state.list[sameIndex].count + goods.count
        state.list.splice(sameIndex, 1)
      }
      state.list.unshift(goods)
    },
    // 修改购物车
    updateCart(state, goods) {
      // goods 商品信息: nowPrice stock isEffetive
      // goods 商品对象的字段不固定 ,对象中有哪些字段就改哪些字段,因为可能只有价格改变,商品的有效性并不会改变,字段的值合理才会改
      // goods 商品对象 必须要有SKUid
      const updateGoods = state.list.find((item) => item.skuId === goods.skuId)
      for (const key in updateGoods) {
        // 遍历vuex中商品的每一个key,进行赋值
        if (goods[key] !== null && goods[key] !== undefined && goods[key] !== '') {
          updateGoods[key] = goods[key]
        }
      }
    },
    deleteCart(state, skuId) {
      // 删除操作的逻辑
      const index = state.list.find((item) => {
        return item.skuId === skuId
      })
      state.list.splice(index, 1)
    },
    setCartList(state, list) {
      // 直接赋值为空
      state.list = list
    }
  },
  actions: {
    // 加入购物车
    insertCart(ctx, goods) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 已登录 TODO
          insertCart({ skuId: goods.skuId, count: goods.count })
            .then(() => {
              return findCart()
            })
            .then((data) => {
              ctx.commit('setCartList', data.result)
              resolve()
            })
        } else {
          // 未登录
          ctx.commit('insertCart', goods)
          resolve()
        }
      })
    },
    // 修改购物车的选中状态 单选
    updateCart(ctx, payload) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 登录状态
          updateCart(payload)
            .then(() => {
              return findCart()
            })
            .then((data) => {
              ctx.commit('setCartList', data.result)
              resolve()
            })
        } else {
          // 未登录
          ctx.commit('updateCart', payload)
          resolve()
        }
      })
    },
    // 获取商品列表  在组件初始化的时候更新购物车
    findCart(ctx) {
      return new Promise((resolve, reject) => {
        // 有登陆和未登录两种状态
        if (ctx.rootState.user.profile.token) {
          // 登录状态
          findCart().then((data) => {
            ctx.commit('setCartList', data.result)
            resolve()
          })
        } else {
          // 未登录状态  就要去获取到所有的需要更新的商品的列表  列表放在本state中的list中
          const promiseAll = ctx.state.list.map((item) => {
            return getNewCartGoods(item.skuId)
          })
          Promise.all(promiseAll)
            .then((dataList) => {
              dataList.forEach((data, i) => {
                ctx.commit('updateCart', { skuId: ctx.state.list[i].skuId, ...data.result })
              })
              resolve()
            })
            .catch((e) => {
              reject(e)
            })
        }
      })
    },
    // 删除购物车的商品
    deleteCart(ctx, skuId) {
      // 判断 是否为登陆的状态
      return new Promise((resolve, reject) => {
        console.log(skuId)
        if (ctx.rootState.user.profile.token) {
          // 登陆状态
          deleteCart([skuId])
            .then(() => {
              return findCart()
            })
            .then((data) => {
              ctx.commit('setCartList', data.result)
              resolve()
            })
        } else {
          // 未登录的状态
          ctx.commit('deleteCart', skuId)
          resolve()
        }
      })
    },
    // 全选状态
    checkAllCart(ctx, selected) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 登陆状态
          const ids = ctx.getters.validList.map((item) => item.selected)
          checkAllCart({ selected, ids })
            .then(() => {
              return findCart()
            })
            .then((data) => {
              ctx.commit('setCartList', data.result)
              resolve()
            })
        } else {
          // 未登录的状态  修改的是数据的选中状态，数据在user/list中存放
          ctx.getters.validList.forEach((item) => {
            ctx.commit('updateCart', { skuId: item.skuId, selected })
          })
          resolve()
        }
      })
    },
    // 批量删除
    batchDeleteCart(ctx, isClear) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 登录状态  登录状态下批量删除有两种情况  一种是删除无效列表 一种是删除有效的列表
          const ids = ctx.getters[isClear ? 'selectedList' : 'invalidList'].map((item) => item.skuId)
          deleteCart(ids)
            .then(() => {
              return findCart()
            })
            .then((data) => {
              ctx.commit('setCartList', data.result)
              resolve()
            })
        } else {
          // 未登录状态
          ctx.getters[isClear ? 'selectedList' : 'invilidList'].forEach((item) => {
            ctx.commit('deleteCart', item.skuId)
          })
          resolve()
        }
      })
    },
    // 更新sku信息
    updateCartSku(ctx, { oldSkuId, newSku }) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 登录状态下
          // 1. 找出旧的商品信息(信息不全，需要去找到对应的信息)  2.删除旧的商品信息  3.合并信息  4.添加新的商品
          const oldGoods = ctx.state.list.find((item) => item.skuId === oldSkuId)
          deleteCart([oldSkuId])
            .then(() => {
              return insertCart({ skuId: newSku.skuId, count: oldGoods.count })
            })
            .then(() => {
              return findCart()
            })
            .then((data) => {
              ctx.commit('setCartList', data.result)
              resolve()
            })
        } else {
          // 未登录状态下
          // 1. 找出旧的商品信息(信息不全，需要去找到对应的信息)  2.删除旧的商品信息  3.合并信息  4.添加新的商品
          const oldGoods = ctx.getters.validList.find((item) => item.skuId === oldSkuId)
          ctx.commit('deleteCart', oldSkuId)
          const { skuId, inventory: stock, price: nowPrice, specsText: attrsText } = newSku
          const newGoods = { ...oldGoods, skuId, stock, nowPrice, attrsText }
          ctx.commit('insertCart', newGoods)
        }
      })
    },
    // 合并购物车
    async mergeLocalCart(ctx) {
      // 合并购物车一定是在登录的情况下去合并
      const cartList = ctx.state.list.map(({ skuId, selected, count }) => {
        return {
          skuId,
          selected,
          count
        }
      })
      await mergeCart(cartList)
      // 合并成功之后要将本地的购物车清空
      ctx.commit('setCartList', [])
    }
  }
}
